﻿using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using EGuayas.Web.Resources;
using EntGuayasSLA.BL;
using EntGuayasSLA.BL.Archivos.Pdf;
using EntGuayasSLA.BL.Listas;
using EntGuayasSLA.BL.Listas.Criterias;
using Ext.Net;

namespace EGuayas.Web.EGlobal
{
    public partial class pgRevisar : pgBase
    {

        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                if (!X.IsAjaxRequest)
                {
                    this.hddCodigoRol.SetValue(GetSessionUsuario.UsuarioRolCodigo);
                    this.hddDirector.SetValue(Valores.Codigo_Rol_Director);
                    //Dependiendo del rol cambia la funcionalidad del boton
                    if (GetSessionUsuario.UsuarioRolCodigo == Valores.Codigo_Rol_Director)
                    {
                        this.btnAprobar.Text = "Aprobar";

                    }
                    else
                    {
                        this.btnAprobar.Text = "Enviar Revisión Director";
                        this.TabPanel1.CloseTab(2, CloseAction.Destroy);
                    }
                }
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }
        }
         #region metodos
        private static void UpdateEstadoInfome(Guid idInforme, string _estado, string _notifica)
        {
            Informe objInforme = Informe.GetEditableRoot(idInforme);
            objInforme.Estado = _estado;
            objInforme.Notifica = _notifica;
            objInforme.Save();

        }
        private static void UpdateEstadoRevisionFase(Guid idArch, string estado)
        {
            RevisionFase objRevFase = RevisionFase.GetEditableRoot(idArch);
            objRevFase.Aprobado = estado;

            objRevFase.Save();
        }
        private static void UpdateInformeRevisionFase(Guid idArch, string estado,string nuevoInfId)
        {
            RevisionFase objRevFase = RevisionFase.GetEditableRoot(idArch);
            objRevFase.Aprobado = estado;
            objRevFase.Informe = nuevoInfId;
            objRevFase.Save();
        }
        

        private static void AgregarRevisionDirector(string revisor, string idInforme)
        {
            RevisionFase objRevFase = RevisionFase.NewEditableRoot();
            objRevFase.Id = Guid.NewGuid();
            objRevFase.PersonaId = GetSessionUsuario.PersonaId;
            objRevFase.RevisorId = revisor;
            objRevFase.Informe = idInforme;
            objRevFase.Fecha = DateTime.Now;
            objRevFase.Aprobado = Valores.Codigo_CHAR_Revizar;
            objRevFase.TipoId = Valores.Codigo_Estado_Inf_RevDir;
            objRevFase.Save();
        }

        /// <summary>
        /// Colocar Revision fase Estado en "N", Informe Estado en "REVDIR"
        /// </summary>
        /// <param name="idArchivo"></param>
        public void EnviaRevizarDirector(Guid idInforme, Guid idRevizar)
        {
            try
            {
                //Determinar cual ditector se envia a revizar. Unico director
                DirectorSubDirLista lista = DirectorSubDirLista.GetDirectorSubDirLista();
                DirectorSubDirInfo dir = lista.FirstOrDefault(r => r.RolCodigo == Valores.Codigo_Rol_Director);
                if (dir != null)
                {
                    AgregarRevisionDirector(dir.PersonaId.ToString(), idInforme.ToString());
                    UpdateEstadoRevisionFase(idRevizar, Valores.Codigo_CHAR_Si);
                    UpdateEstadoInfome(idInforme, Valores.Codigo_Estado_Inf_RevDir, Valores.Codigo_CHAR_No);
                    gpDocRevizados.GetStore().Reload();
                    gpDocumentosLoad.GetStore().Reload();
                    X.Msg.Show(new MessageBoxConfig
                    {
                        Buttons = MessageBox.Button.OK,
                        Icon = MessageBox.Icon.INFO,
                        Title = Titulos.TituloAviso,
                        Message = "Revisión Enviada"
                    });
                }
                else
                {
                    X.Msg.Show(new MessageBoxConfig
                    {
                        Buttons = MessageBox.Button.OK,
                        Icon = MessageBox.Icon.INFO,
                        Title = Titulos.TituloAviso,
                        Message = "No se ha definido funcionario con rol director"
                    });
                }
            }
            catch (Exception ex)
            {
                RegistrarLog("RevizarDirector" + ex);
            }
        }
        private void AprobarDirector(string sComentarios, Guid idRevizar, Guid idInforme, Guid idArch, string sModulo,string estadoDMA)
        {
            Archivo objArch = Archivo.GetEditableRoot(idArch, sModulo);//Modificar para que sea mas generico la consulta listaRevicion--pendiente---LICENCIAMIENTO OK, AUDITORIA PENDIENTE
            //Nueva Ruta de documento
            string filePath = objArch.Ruta;
            string fileExt = filePath.Substring(filePath.LastIndexOf('.') + 1);
            switch (sModulo)
            {
                case "INFDOCLIC":
                    #region "Fases de Licenciamiento"
                    
                    FaseLicenciamientoLista itemsSelect = FaseLicenciamientoLista.GetFaseLicenciamientoLista(Guid.Parse(objArch.ExpedienteId));
                    //Actualizar estado actual
                    FaseLicenciamientoInfo faseFirst = itemsSelect.FirstOrDefault(r => r.EstadoFase == Valores.Codigo_Estado_Fase_Proceso);
                    if (faseFirst != null)
                    {
                        FaseLicenciamiento objFaseLic = FaseLicenciamiento.GetEditableRoot(faseFirst.Id);
                        objFaseLic.EstadoFase = Valores.Codigo_Estado_Fase_Finalizado;
                        objFaseLic.EstadoDMA = estadoDMA;
                        objFaseLic.Save();
                        //Aqui se guarda el estado de DMA
                        var objEstadoFase = EstadoFaseLicenciamiento.NewEditableRoot();
                        objEstadoFase.Id = System.Guid.NewGuid();
                        objEstadoFase.FaseLicId = faseFirst.Id.ToString();//En este caso es fal_id
                        objEstadoFase.FechaEFL = DateTime.Now;
                        objEstadoFase.EstadoFase = estadoDMA;
                        objEstadoFase.Save();
                        //Actualizar estado siguiente
                        faseFirst = itemsSelect.FirstOrDefault(r => r.EstadoFase == Valores.Codigo_Estado_Fase_Creado);
                        if ((estadoDMA == Valores.EstadoAceptado || estadoDMA == Valores.EstadoAprobado ||
                             estadoDMA == Valores.EstadoAprobadoObservado) && faseFirst != null)
                        {
                            FaseLicenciamiento objFaseLice = FaseLicenciamiento.GetEditableRoot(faseFirst.Id);
                            objFaseLice.EstadoFase = Valores.Codigo_Estado_Fase_Inicial;
                            objFaseLice.Save();

                            //CAMBIAR ESTADO INDICAR QUE SE HA COMPLETADO CREACION
                            ExpedienteLicenciamiento objExpLic =
                                ExpedienteLicenciamiento.GetEditableRoot(Guid.Parse(objArch.ExpedienteId));
                            objExpLic.Estado = faseFirst.NombreFase;
                            objExpLic.CodigoFase = faseFirst.CodigoFase;
                            objExpLic.FechaFaseAprobacion = DateTime.Now;
                            objExpLic.Save();
                        }
                        else
                        {
                            //Se cambia a fase reingreso
                            objFaseLic.EstadoFase = Valores.Codigo_Estado_Fase_Reingreso;
                        }
                    }
                    
                    #endregion
                    break;
                case "INFDOCAUDCUM":
                    #region "Fases de auditoria de cumplimiento"

                    var faseAudCump = FaseAuditoria.GetEditableRoot(Guid.Parse(objArch.GlobalRelacionId));
                    //Solo si esta en proceso cambiar a inicial las dos siguientes fases, Calculo de costos y Auditoria
                    if (faseAudCump.EstadoFase == Valores.Codigo_Estado_Fase_Proceso)
                    {
                        FaseAuditoriaCumplimientoLista listaFases = FaseAuditoriaCumplimientoLista.GetFaseAuditoriaCumplimientoLista(Guid.Parse(objArch.GlobalRelacionId));
                        //Si es fase de TDR, cambiar las dos siguientes fases, Calculo de costos y Auditoria a fase inicial, caso contrario
                        //Si fase es Calculo de tasas, no cambiar nada para siguiente fase
                        //Si fase es auditoria cambiar a Poliza el estado a inicial
                        //Si fase es poliza terminar la auditoria de cumplimiento.
                        if ((estadoDMA == Valores.EstadoAceptado || estadoDMA == Valores.EstadoAprobado ||
                             estadoDMA == Valores.EstadoAprobadoObservado))
                        {
                            var faseACosto = listaFases.FirstOrDefault(lf => lf.CodigoFase == Constantes.ACosto);
                            var audCumplimiento = AuditoriaCumplimiento.GetEditableRoot(faseACosto.IdAuditoriaCump);

                            switch (faseAudCump.CodigoFase)
                            {
                                case Constantes.ATDR:
                                    var faseAAuditoria =
                                        listaFases.FirstOrDefault(lf => lf.CodigoFase == Constantes.AAuditoria);
                                    var faseCosto = FaseAuditoria.GetEditableRoot(faseACosto.Id);
                                    var faseAuditoria = FaseAuditoria.GetEditableRoot(faseAAuditoria.Id);
                                    faseCosto.EstadoFase = Valores.Codigo_Estado_Fase_Inicial;
                                    faseAuditoria.EstadoFase = Valores.Codigo_Estado_Fase_Inicial;
                                    faseCosto.Save();
                                    faseAuditoria.Save();
                                    //Cambia estado a Auditoria de cumplimiento para conocer en que fase esta.
                                    audCumplimiento.Estado = string.Format("{0} - {1}", faseACosto.NombreFase,
                                                                           faseAAuditoria.NombreFase);

                                    break;
                                case Constantes.ACosto:
                                    break;
                                case Constantes.AAuditoria:
                                    var faseAPoliza =
                                        listaFases.FirstOrDefault(lf => lf.CodigoFase == Constantes.APoliza);
                                    var fasePoliza = FaseAuditoria.GetEditableRoot(faseAPoliza.Id);
                                    fasePoliza.EstadoFase = Valores.Codigo_Estado_Fase_Inicial;
                                    fasePoliza.Save();
                                    //Cambia estado a Auditoria de cumplimiento para conocer en que fase esta.
                                    audCumplimiento.Estado = string.Format("{0}", faseAPoliza.NombreFase);
                                    break;
                                case Constantes.APoliza:
                                    //Cambia estado a Auditoria de cumplimiento para conocer finalizo la misma
                                    audCumplimiento.Estado = "FINALIZADO";

                                    break;
                            }
                            audCumplimiento.CodigoFase = faseAudCump.CodigoFase;
                            audCumplimiento.FechaFaseAprobacion = DateTime.Now;
                            audCumplimiento.Save();
                            //Fase Actual cambiar a finalizado
                            faseAudCump.EstadoFase = Valores.Codigo_Estado_Fase_Finalizado;
                        }
                        else
                        {
                            //Fase Actual cambiar a finalizado
                            faseAudCump.EstadoFase = Valores.Codigo_Estado_Fase_Reingreso;
                        }


                        faseAudCump.Save();
                        //PENDIENTE:Restriccion para firmar debe ingresar a este bloque de codigo #region completar proceso
                    }
                    

                    
                    #endregion
                    break;
                case "INFDOCAUDMON":
                    #region "Monitoreo"
                    var faseAudMon = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(objArch.GlobalRelacionId));
                    faseAudMon.EstadoDMA = estadoDMA;
                    if ((estadoDMA == Valores.EstadoAceptado || estadoDMA == Valores.EstadoAprobado ||
                         estadoDMA == Valores.EstadoAprobadoObservado))
                    {
                        //faseAudMon
                        //Fase Actual cambiar a finalizado
                        faseAudMon.EstadoFase = Valores.Codigo_Estado_Fase_Finalizado;
                    }
                    else
                    {
                        //Fase Actual cambiar a reingreso de informacion
                        faseAudMon.EstadoFase = Valores.Codigo_Estado_Fase_Reingreso;
                    }
                    
                    faseAudMon.Save();
                    //PENDIENTE:Restriccion para firmar debe ingresar a este bloque de codigo #region completar proceso
                    
                    #endregion
                    break;
                case "INFDOCAUDPMA":
                    #region "Cumplimiento de PMA"
                    var faseAudPMA = AuditoriaPMA.GetEditableRoot(Guid.Parse(objArch.GlobalRelacionId));
                    faseAudPMA.EstadoDMA = estadoDMA;
                    if ((estadoDMA == Valores.EstadoAceptado || estadoDMA == Valores.EstadoAprobado ||
                         estadoDMA == Valores.EstadoAprobadoObservado))
                    {
                        
                        //Fase Actual cambiar a finalizado
                        faseAudPMA.EstadoFase = Valores.Codigo_Estado_Fase_Finalizado;

                    }
                    else
                    {
                        //Fase Actual cambiar a reingreso de informacion
                        faseAudPMA.EstadoFase = Valores.Codigo_Estado_Fase_Reingreso;
                    }

                    faseAudPMA.Save();
                    #endregion
                    break;
                case "INFDOCAUDOTRO":
                    #region "Otros procesos de auditoria"
                    //Aqui hay que tomar en cosideración algunos sub procesos que se pueden generar, uno de ellos es crear o activar otro proceso de otros
                    var audOtro = AuditoriaOtros.GetEditableRoot(Guid.Parse(objArch.GlobalRelacionId));
                    audOtro.EstadoDMA = estadoDMA;
                        if ((estadoDMA == Valores.EstadoAceptado || estadoDMA == Valores.EstadoAprobado ||
                             estadoDMA == Valores.EstadoAprobadoObservado))
                        {
                            //Fase Actual cambiar a finalizado
                            audOtro.EstadoFase = Valores.Codigo_Estado_Fase_Finalizado;
                            //Asignar id de monitoreo, pma, otros
                            var monOtroId = audOtro.MonitoreoIdAdd;
                            var monPmaId = audOtro.PmaIdAdd;
                            var otroOtroId = audOtro.OtrosIdAdd2;
                            bool opcSalir;
                            do
                            {
                                if (!string.IsNullOrEmpty(monOtroId))
                                {
                                    var monOtros = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(monOtroId));
                                    if (monOtros != null)
                                    {
                                        monOtros.EstadoDMA = Valores.Codigo_Estado_Fase_Finalizado;
                                        monOtros.Save();
                                        break;
                                    }
                                }
                                if (!string.IsNullOrEmpty(monPmaId))
                                {
                                    var pmaOtros = AuditoriaPMA.GetEditableRoot(Guid.Parse(monPmaId));
                                    if (pmaOtros != null)
                                    {
                                        pmaOtros.EstadoDMA = Valores.Codigo_Estado_Fase_Finalizado;
                                        pmaOtros.Save();
                                        break;
                                    }
                                }
                                if (!string.IsNullOrEmpty(otroOtroId))
                                {
                                    var otroOtros = AuditoriaOtros.GetEditableRoot(Guid.Parse(otroOtroId));
                                    if (otroOtros != null)
                                    {
                                        otroOtros.EstadoDMA = Valores.Codigo_Estado_Fase_Finalizado;
                                        otroOtros.Save();
                                        //Asignar id de monitoreo, pma, otros
                                        monOtroId = null;
                                        monPmaId = null;
                                        otroOtroId = null;
                                        monOtroId = otroOtros.MonitoreoIdAdd;
                                        monPmaId = otroOtros.PmaIdAdd;
                                        otroOtroId = otroOtros.OtrosIdAdd2;
                                    }
                                }
                                opcSalir = !string.IsNullOrEmpty(otroOtroId) || !string.IsNullOrEmpty(monPmaId) || !string.IsNullOrEmpty(monPmaId);
                            } while (opcSalir);
                        }
                        else
                        {
                            //Fase Actual cambiar a Reingreso
                            audOtro.EstadoFase = Valores.Codigo_Estado_Fase_Reingreso;
                        }

                        audOtro.Save();
                    
                    #endregion
                    break;
            }


            #region completar proceso
            //Actualizar estados
            UpdateEstadoRevisionFase(idRevizar, Valores.Codigo_CHAR_Si);
            //Aun no se debe actualizar este informe para ser notificado al promotor - regulado ya que aun no esta firmado
            UpdateEstadoInfome(idInforme, Valores.Codigo_Estado_Inf_Aprobado, Valores.Codigo_CHAR_No);
            //No se debe cambiar esta referencia
            //objArch.Referencia = objArch.Id.ToString();
            if (sComentarios != "")
            {
                objArch.Comentarios = sComentarios;
                if (fileExt.ToLower() == "pdf")
                    objArch.RequiereFirmar = Valores.Codigo_CHAR_Si;
                objArch.Save();
            }
            else
            {
                if (fileExt.ToLower() == "pdf")
                    objArch.RequiereFirmar = Valores.Codigo_CHAR_Si;
                objArch.Save();
            }
            this.gpDocRevizados.GetStore().Reload();
            this.gpDocumentosLoad.GetStore().Reload();

            //Ids para enviar a firmar documento
            string idArchEnv = "";
            string idRutaEnv = "";

            if (fileExt.ToLower() != "pdf")
            {
                string fileNewName = filePath.Substring(0, filePath.LastIndexOf('.') + 1) + "pdf";
                //Metodo de conversion a pdf

                //Crear nueva version de archivo formato pdf
                Archivo objArchNewVer = Archivo.NewEditableRoot(sModulo);
                objArchNewVer.Id = System.Guid.NewGuid();
                //Referenciar a la referencia del archivo anterior
                objArchNewVer.Referencia = objArch.Referencia; //objArchNewVer.Referencia = objArch.Id.ToString();
                objArchNewVer.TipoDocumento = objArch.TipoDocumento;
                objArchNewVer.Version = objArch.Version + 1;
                //Para recuperar el nombre original y colocarle la version.
                if(objArch.Nombre.LastIndexOf("V")>0)
                    objArchNewVer.Nombre = objArch.Nombre.Substring(0, objArch.Nombre.LastIndexOf("V")) + " V" + objArchNewVer.Version.ToString();
                else
                    objArchNewVer.Nombre = objArch.Nombre + " V" + objArchNewVer.Version.ToString();
                
                objArchNewVer.Descripcion = "";
                objArchNewVer.FechaCreacion = DateTime.Now;
                objArchNewVer.RequiereFirmar = Valores.Codigo_CHAR_Si;
                objArchNewVer.Firmado = Valores.Codigo_CHAR_No;
                objArchNewVer.RequiereFirmar = Valores.Codigo_CHAR_Si;
                objArchNewVer.PersonaId = objArch.PersonaId;
                objArchNewVer.GlobalRelacionId = objArch.GlobalRelacionId;
                objArchNewVer.CodigoFase = objArch.CodigoFase;
                objArchNewVer.ExpedienteId = objArch.ExpedienteId;
                objArchNewVer.Ruta = fileNewName;
                objArchNewVer.Save();
                //Debe asociar el nuevo informe con la revision_fase
                UpdateInformeRevisionFase(idArch, "ASOINF", objArchNewVer.Id.ToString());
                //Parametros de firmar
                idArchEnv = objArchNewVer.Id.ToString();
                idRutaEnv = objArchNewVer.Ruta;

            }
            else
            {
                idArchEnv = objArch.Id.ToString();
                idRutaEnv = objArch.Ruta;

            }
            //Confirmacion para firmar docuemnto
            X.Msg.Confirm("Aviso", "Desea Firmar documento?", new MessageBoxButtonsConfig
            {
                Yes = new MessageBoxButtonConfig
                {
                    Handler = "DMRevizar.DoYes('" + sModulo + "','" + idArchEnv + "','" + idRutaEnv + "')",
                    Text = "Si"
                },
                No = new MessageBoxButtonConfig
                {
                    Text = "No"
                }
            }).Show();

            #endregion

        }
        #endregion
        [DirectMethod]
        public void DoYes(string Modulo,string Id, string Ruta)
        {
            MaskConfig cfg = new MaskConfig();
            cfg.Msg = "Esperar ...";
            cfg.El = "Ext.getBody()";
            X.Mask.Show(cfg);
            this.wucFirma.ShowDetailsFirma(Modulo,Id, Ruta);
            X.Mask.Hide();
        }
        #region Expander Grid
        protected static void GrdSubDoc_Command(object sender, DirectEventArgs e)
        {
            /*
                string commandName = e.ExtraParams["command"];
                long Id = Convert.ToInt64(e.ExtraParams["Id"]);
            */
        }
        [DirectMethod]
        public static string GetSubDoc(Dictionary<string, string> parameters)
        {
            ArchivoSubArchivosCriteria criteria = ArchivoSubArchivosCriteria.NewArchivoSubArchivosCriteria();
            criteria.Id = parameters["id"];
            criteria.Tabla = parameters["tabla"];

            var data = ArchivoLista.GetArchivoLista(criteria);


            if (data.Count != 0)
            {
                /*
                    <ext:ModelField Name="FaseLicId" Type="String" />
                    <ext:ModelField Name="FechaCreacion" Type="Date" />
                    <ext:ModelField Name="FechaFirmado" Type="Date" />
                    <ext:ModelField Name="Firmado" Type="String" />
                    <ext:ModelField Name="Id" Type="String" />
                    <ext:ModelField Name="Descripcion" Type="String" />
                    <ext:ModelField Name="Nombre" Type="String" />
                    <ext:ModelField Name="PersonaId" Type="String" />
                    <ext:ModelField Name="PersonaNombres" Type="String" />
                    <ext:ModelField Name="Referencia" Type="String" />
                    <ext:ModelField Name="RequiereFirmar" Type="String" />
                    <ext:ModelField Name="Ruta" Type="String" />
                    <ext:ModelField Name="TipoDocumento" Type="String" />
                    <ext:ModelField Name="Version" Type="Int" />
           
                 */
                GridPanel grid = new GridPanel
                {
                    Height = 90,
                    EnableColumnHide = false,
                    Store = 
                        { 
                            new Store 
                            { 
                                Model = {
                                    new Model {
                                        IDProperty = "Id",
                                        Fields = 
                                        {
                                            new ModelField("Id"),
                                            new ModelField("Nombre"),
                                            new ModelField("Descripcion"),
                                            new ModelField("FechaCreacion"),
                                            new ModelField("Version"),
                                            new ModelField("Ruta")
                                        }
                                    }
                                },
                                DataSource = data
                            }
                        },
                    ColumnModel =
                    {
                        Columns = { }
                    },

                };


                Column addColumn1 = new Column();
                addColumn1.Text = "Nombre";
                addColumn1.DataIndex = "Nombre";
                addColumn1.Flex = 4;
                grid.ColumnModel.Columns.Add(addColumn1);

                Column addColumn2 = new Column();
                addColumn2.Text = "Descripción";
                addColumn2.DataIndex = "Descripcion";
                addColumn2.Flex = 4;
                grid.ColumnModel.Columns.Add(addColumn2);

                Column addColumn3 = new Column();
                addColumn3.Text = "Fecha";
                addColumn3.DataIndex = "FechaCreacion";
                addColumn3.Flex = 4;
                grid.ColumnModel.Columns.Add(addColumn3);

                Column addColumn4 = new Column();
                addColumn4.Text = "Versión";
                addColumn4.DataIndex = "Version";
                addColumn4.Flex = 4;
                grid.ColumnModel.Columns.Add(addColumn4);

                CommandColumn commandColumn = new CommandColumn();
                commandColumn.ID = "colAction" + System.Guid.NewGuid();
                commandColumn.Flex = 1;
                //commandColumn.Text = "Visualizar";
                commandColumn.DataIndex = "Id";
                commandColumn.Commands.Add(new GridCommand { Icon = Ext.Net.Icon.Zoom, CommandName = "View", Text = "Vizualizar" });
                commandColumn.Listeners.Command.Handler = "AppGlobalJs.showPdf('../../..',record.data.Ruta);";


                //commandColumn.DirectEvents.Command.Event += GrdSubDoc_Command;
                //commandColumn.DirectEvents.Command.ExtraParams.Add(new Parameter { Name = "Id", Value = "record.data.Id" });
                //commandColumn.DirectEvents.Command.ExtraParams.Add(new Parameter { Name = "command", Value = "command" });
                grid.ColumnModel.Columns.Add(commandColumn);
                return ComponentLoader.ToConfig(grid);
            }
            else
            {
                Ext.Net.Panel pnlIfo = new Ext.Net.Panel();

                pnlIfo.Html = "<p>Sin versiones</p>";
                pnlIfo.Height = 45;
                return ComponentLoader.ToConfig(pnlIfo);
            }
           
        }
        #endregion Expander Grid
        [DirectMethod]
        public ArchivoLista BindDataRevizar()
        {
            try
            {
                ArchivoRevisorCriteria archCriteria = ArchivoRevisorCriteria.NewArchivoRevisorCriteria();
                archCriteria.RevisorId = GetSessionUsuario.PersonaId;
                archCriteria.Aprobado = Valores.Codigo_CHAR_Revizar;
                return ArchivoLista.GetArchivoLista(archCriteria);
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }
            return null;
        }
        //
        [DirectMethod]
        public void ShowAllFiles(string idFase, string idModulo)
        {
            ucInfoDocumentos.Show(idFase, idModulo);

        }
        [DirectMethod]
        public ArchivoLista BindDataComentario()
        {
            try
            {
                if (GetSessionUsuario.UsuarioRolCodigo == Valores.Codigo_Rol_Director)
                {
                    ArchivoEmisorCriteria archCriteria = ArchivoEmisorCriteria.NewArchivoEmisorCriteria();
                    archCriteria.EmisorId = GetSessionUsuario.PersonaId;
                    archCriteria.Estado = Valores.Codigo_CHAR_No;
                    return ArchivoLista.GetArchivoLista(archCriteria);
                }
                return null;
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }
            return null;
        }
        [DirectMethod]
        public ArchivoLista BindDataRevizados()
        {
            try
            {

                //string _stadoRevizor = Valores.Codigo_Estado_Inf_RevDir + "," + Valores.Codigo_Estado_Inf_RevSubDir;
                ArchivoRevisorCriteria archCriteria = ArchivoRevisorCriteria.NewArchivoRevisorCriteria();
                archCriteria.RevisorId = GetSessionUsuario.PersonaId;
                archCriteria.Aprobado = Valores.Codigo_CHAR_Si + "," + Valores.Codigo_CHAR_No;
                //archCriteria.Estado = _stadoRevizor+ ","+ Valores.Codigo_Estado_Inf_Aprobado + "," + Valores.Codigo_Estado_Inf_Notificado;
                return ArchivoLista.GetArchivoLista(archCriteria);
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }
            return null;
        }
        protected void RevApro_Command(object sender, DirectEventArgs e)
        {
            try
            {
                stoEstadosDMA.DataSource = EstadoFaseLista.GetEstadoFase(e.ExtraParams["CodigoFase"]);
                stoEstadosDMA.DataBind();
                switch (e.ExtraParams["TablaInfo"])
                {
                    case Valores.Modulo_Archivo_Informes_Licenciamiento:
                        FaseLicenciamiento faseLic = FaseLicenciamiento.GetEditableRoot(Guid.Parse(e.ExtraParams["TablaId"]));
                        cbxEstadoDMA.SetValue(faseLic.EstadoDMA);
                        break;
                    case Valores.Modulo_Archivo_Informes_Aud_Cump:
                        FaseAuditoria faseAud = FaseAuditoria.GetEditableRoot(Guid.Parse(e.ExtraParams["TablaId"]));
                        cbxEstadoDMA.SetValue(faseAud.EstadoDMA);
                        break;
                    case Valores.Modulo_Archivo_Informes_Aud_Moni:
                        AuditoriaMonitoreo mon = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(e.ExtraParams["TablaId"]));
                        cbxEstadoDMA.SetValue(mon.EstadoDMA);
                        break;
                    case Valores.Modulo_Archivo_Informes_Aud_Pma:
                        AuditoriaPMA pma = AuditoriaPMA.GetEditableRoot(Guid.Parse(e.ExtraParams["TablaId"]));
                        cbxEstadoDMA.SetValue(pma.EstadoDMA);
                        break;
                    case Valores.Modulo_Archivo_Informes_Aud_Otro:
                        AuditoriaOtros ots = AuditoriaOtros.GetEditableRoot(Guid.Parse(e.ExtraParams["TablaId"]));
                        cbxEstadoDMA.SetValue(ots.EstadoDMA);
                        break;
                }
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }

        }
        protected void btnAprobar_Click(object sender, DirectEventArgs e)
        {
            try
            {

                Guid idRevizar = Guid.Parse(e.ExtraParams["IdRevision"]);
                Guid idInforme = Guid.Parse(e.ExtraParams["IdInforme"]);
                Guid idArch = Guid.Parse(e.ExtraParams["IdArchivo"]);
                if (GetSessionUsuario.UsuarioRolCodigo == Valores.Codigo_Rol_Director)
                {

                    AprobarDirector(e.ExtraParams["Comentarios"], idRevizar, idInforme, idArch, e.ExtraParams["Modulo"], e.ExtraParams["EstadoDMA"]);
                }
                else
                {
                    EnviaRevizarDirector(idInforme, idRevizar);
                }
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }

        }
        protected void btnComentarios_Click(object sender, DirectEventArgs e)
        {
            try
            {
                Guid idArch = Guid.Parse(e.ExtraParams["IdArchivo"]);

                Archivo objArch = Archivo.GetEditableRoot(idArch, e.ExtraParams["Modulo"]);

                objArch.Comentarios = objArch.Comentarios + e.ExtraParams["Comentarios"] + " \n[" + GetSessionUsuario.UsuarioRolNombre + "] \n";
                objArch.Save();


                gpDocComentarios.GetStore().Reload();
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon = MessageBox.Icon.INFO,
                    Title = Titulos.TituloAviso,
                    Message = "Comentario Agregado"
                });
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }

        }
        /// <summary>
        /// Descargar archivo
        /// </summary>
        /// <param name="patch"></param>
        private void Download(string patch)
        {
            string pathFile = MapPath(patch);
            System.IO.FileInfo toDownload =
               new System.IO.FileInfo(pathFile);
            string fileExt = pathFile.Substring(pathFile.LastIndexOf('.') + 1);

            MaskConfig cfg = new MaskConfig();
            cfg.Msg = "Descargando archivo ...";
            cfg.El = "Ext.getBody()";
            X.Mask.Show(cfg);


            if (fileExt.ToLower() == "pdf")
            {
                byte[] OWNER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("PwdPdf"));
                using (MemoryStream memory = Pdf.DecryptFilePdf(pathFile, OWNER))
                {
                    //Response.Clear();
                    //Response.ContentType = "application/pdf";
                    //Response.OutputStream.Write(memory.GetBuffer(), 0, memory.GetBuffer().Length);
                    //Response.OutputStream.Close();                   
                    //HttpContext.Current.ApplicationInstance.CompleteRequest();
                    byte[] bytes = memory.ToArray();
                    Response.Clear();
                    Response.ContentType = "application/force-download";
                    Response.AddHeader("content-disposition", "attachment; filename=" + toDownload.Name);
                    Response.BinaryWrite(bytes);
                    Response.End();

                }
            }
            else
            {
                Response.Clear();
                Response.AddHeader("Content-Disposition",
                                   "attachment; filename=" + toDownload.Name);
                Response.AddHeader("Content-Length",
                                   toDownload.Length.ToString());
                Response.ContentType = "application/octet-stream";
                Response.WriteFile(patch);
                Response.End();
            }
            //
            X.Mask.Hide();
        }
        // 
        protected void btnDowload_Click(object sender, DirectEventArgs e)
        {
            try
            {
                //PENDIENTE: Caso pdf decriptar para descargarlo
                this.Download(e.ExtraParams["Ruta"]);

            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }

        }
        private string loadNewVersion(DirectEventArgs e, Archivo objArchAnterior)
        {
            Boolean valDone = this.FileUploadDocUp.HasFile;
            string RefId = "";
            if (valDone)
            {

                int version = 0;
                string ruta = "";
                string fileName = "";
                string fileNameTmp = "";
                string fileExt = this.FileUploadDocUp.PostedFile.FileName.Substring(this.FileUploadDocUp.PostedFile.FileName.LastIndexOf('.') + 1);
                Archivo objNuevaVersArch = Archivo.NewEditableRoot(e.ExtraParams["Modulo"]);
                objNuevaVersArch.Id = System.Guid.NewGuid();
                //Nuevas versiones datos correguidos
                objNuevaVersArch.SubirNuevo = "C";
                Int32.TryParse(e.ExtraParams["hddnDocUpVers"], out version);
                version = version + 1;
                this.GetNameFile(this.FileUploadDocUp, fileExt, ref ruta, ref fileName, ref fileNameTmp);
                byte[] USER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("UserPdf"));
                byte[] OWNER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("PwdPdf"));

                if (fileExt.ToLower() == "pdf")
                {
                    this.FileUploadDocUp.PostedFile.SaveAs(fileNameTmp);
                    Pdf.EncryptFilePdf(fileNameTmp, fileName, USER, OWNER);
                    File.Delete(fileNameTmp);
                }
                else
                {
                    this.FileUploadDocUp.PostedFile.SaveAs(fileName);
                }

                if (version > 2)
                {
                    objNuevaVersArch.Referencia = e.ExtraParams["hddnDocUpRef"];
                    objNuevaVersArch.TipoDocumento = objArchAnterior.TipoDocumento;
                }
                else
                {
                    if (version == 2)
                    {

                        objNuevaVersArch.Referencia = e.ExtraParams["IdArchivo"];
                        if (objArchAnterior.Referencia == "")
                        {
                            RefId = objArchAnterior.Id.ToString();

                        }
                        objNuevaVersArch.TipoDocumento = objArchAnterior.TipoDocumento;
                    }
                }
                objNuevaVersArch.Version = version;
                objNuevaVersArch.Nombre = objArchAnterior.Nombre + " V" + version.ToString();
                objNuevaVersArch.Descripcion = objArchAnterior.Descripcion;
                objNuevaVersArch.FechaCreacion = DateTime.Now;
                objNuevaVersArch.RequiereFirmar = Valores.Codigo_CHAR_No;
                objNuevaVersArch.Firmado = Valores.Codigo_CHAR_No;
                objNuevaVersArch.RequiereFirmar = Valores.Codigo_CHAR_No;
                objNuevaVersArch.PersonaId = GetSessionUsuario.PersonaId;
                objNuevaVersArch.GlobalRelacionId = objArchAnterior.GlobalRelacionId;
                objNuevaVersArch.ExpedienteId = objArchAnterior.ExpedienteId;
                objNuevaVersArch.Ruta = ruta;
                objNuevaVersArch.SubirNuevo = Valores.Codigo_CHAR_Si;
                objNuevaVersArch.Save();
            }
            return RefId;
        }
        protected void btnCorreguir_Click(object sender, DirectEventArgs e)
        {
            try
            {
                Guid idArch = Guid.Parse(e.ExtraParams["IdArchivo"]);
                Guid idRevi = Guid.Parse(e.ExtraParams["IdRevision"]);
                Archivo objArch = Archivo.GetEditableRoot(idArch, e.ExtraParams["Modulo"]);
                objArch.SubirNuevo = Valores.Codigo_CHAR_Si;
                objArch.Comentarios = e.ExtraParams["Comentarios"] + " \n[" + GetSessionUsuario.UsuarioRolNombre + "] \n";
                string idRef = loadNewVersion(e, objArch);
                if (idRef != "")
                    objArch.Referencia = idRef;
                objArch.Save();

                UpdateEstadoRevisionFase(idRevi, Valores.Codigo_CHAR_No);
                gpDocRevizados.GetStore().Reload();
                gpDocumentosLoad.GetStore().Reload();
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon = MessageBox.Icon.INFO,
                    Title = Titulos.TituloAviso,
                    Message = "Informe notificado a correción"
                });
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }

        }
        /// <summary>
        /// Bind de comentarios de archivo
        /// </summary>
        /// <param name="action"></param>
        /// <param name="extraParams"></param>
        /// <returns></returns>
        [DirectMethod]
        public ComentariosLista BindDataComentariosVersion(string action, Dictionary<string, object> extraParams)
        {
            try
            {
                string queryPrm = extraParams.ContainsKey("idArchivo") ? extraParams["idArchivo"].ToString() : "";
                if (queryPrm != "")
                {
                    return ComentariosLista.GetComentariosLista(queryPrm);
                }
                return null;
            }
            catch (Exception ex)
            {
                RegistrarLog("wucOtros.BindDataAddArchivos" + ex);
            }
            return null;

        }


    }
}